home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / newton / slider.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  7KB  |  375 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  * slider stuff
  19.  * Yossi Friedman, July 1988
  20.  */
  21.  
  22. #include <stdio.h>
  23. #include <gl.h>
  24. #include <device.h>
  25.  
  26. #include "slider.h"
  27.  
  28. void draw_slider(int sid);
  29.  
  30.  
  31. /*
  32.  * indices into a coordinate vector
  33.  */
  34. #define X 0
  35. #define Y 1
  36.  
  37.  
  38.  
  39. static struct slider_state {
  40.     char *progname;
  41.     char *title;
  42.  
  43.     int wid;
  44.     int menu;
  45.     long orig[2];
  46.     short state;
  47.     short omx;
  48.     float unit;
  49.     float ctl_points[6][2];
  50.  
  51.     float lo, hi, dflt;
  52.     float val;        /* current value of the slider */
  53.     void (*fun)(float);
  54. } sliders[100], *end_sliders = sliders;
  55.  
  56.  
  57.  
  58.  
  59. /* values for state field of slider_state structure */
  60. #define SLIDER_IDLE    0
  61. #define SLIDER_SLIDING    1
  62.  
  63.  
  64.  
  65. int
  66. define_slider(
  67.     char *progname, char *title,
  68.     float lo, float hi, float dflt,
  69.     void (*fun)(float))
  70. {
  71.     end_sliders->progname = (char *)malloc(strlen(progname) + 1);
  72.     if (end_sliders->progname == NULL) {
  73.     fprintf(stderr, "slider: Could not malloc\n");
  74.     my_exit(1);
  75.     }
  76.     strcpy(end_sliders->progname, progname);
  77.  
  78.     end_sliders->title = (char *)malloc(strlen(title) + 1);
  79.     if (end_sliders->title == NULL) {
  80.     fprintf(stderr, "slider: Could not malloc\n");
  81.     my_exit(1);
  82.     }
  83.     strcpy(end_sliders->title, title);
  84.     
  85.     end_sliders->lo = lo;
  86.     end_sliders->hi = hi;
  87.     end_sliders->dflt = dflt;
  88.     end_sliders->val = dflt;
  89.     end_sliders->fun = fun;
  90.     /* (*end_sliders->fun)(dflt);  -- compiler bug. */
  91.     (*fun)(dflt);
  92.  
  93.     end_sliders->unit = (hi - lo) / 500.;
  94.     end_sliders->state = SLIDER_IDLE;
  95.  
  96.     end_sliders->ctl_points[0][X] = 10.;
  97.     end_sliders->ctl_points[2][X] = 510.;
  98.     end_sliders->ctl_points[0][Y] =
  99.     end_sliders->ctl_points[1][Y] =
  100.     end_sliders->ctl_points[2][Y] = 20.;
  101.     
  102.     end_sliders->ctl_points[3][X] = 510.;
  103.     end_sliders->ctl_points[5][X] = 10.;
  104.     end_sliders->ctl_points[3][Y] =
  105.     end_sliders->ctl_points[4][Y] =
  106.     end_sliders->ctl_points[5][Y] = 40.;
  107.  
  108.     end_sliders->wid = -1;
  109.     end_sliders->menu = NULL;
  110.  
  111.     return(end_sliders++ - sliders);
  112. }
  113.  
  114.  
  115. long
  116. open_slider(int sid)
  117. {
  118.     struct slider_state *sp = &sliders[sid];
  119.     long wid = winget();
  120.     
  121.     if (sp->wid == -1) {
  122.     prefsize(520, 50);
  123.     sp->wid = winopen(sp->progname);
  124.     prefsize(520, 50);
  125.     winconstraints();
  126.     wintitle(sp->title);
  127.  
  128.     getorigin(&sp->orig[X], &sp->orig[Y]);
  129.     
  130.     ortho2(0., 520., 0., 50.);
  131.     doublebuffer();
  132.     RGBmode();
  133.     gconfig();
  134.     }
  135.     else {
  136.     winset(sp->wid);
  137.     winpop();
  138.     }
  139.  
  140.     draw_slider(sid);
  141.  
  142.     if (wid != -1)
  143.     winset(wid);
  144.  
  145.     return(sp->wid);
  146. }
  147.  
  148.  
  149. int
  150. close_slider(int sid)
  151. {
  152.     struct slider_state *sp = &sliders[sid];
  153.  
  154.     if (sp->menu != NULL) {
  155.     freepup(sp->menu);
  156.     sp->menu = NULL;
  157.     }
  158.     
  159.     winclose(sp->wid);
  160.     sp->wid = -1;
  161. }
  162.  
  163.  
  164. int
  165. set_slider_default(int sid, float val)
  166. {
  167.     sliders[sid].dflt = val;
  168.     sliders[sid].menu = NULL;    /* force new menu to be created */
  169. }
  170.  
  171.  
  172. int set_slider(int sid, float val)
  173. {
  174.     void (*fun)(float);        /* compiler bug */
  175.  
  176.     sliders[sid].val = val;
  177.     draw_slider(sid);
  178.     fun = sliders[sid].fun;
  179.     (*fun)(val);
  180. }
  181.  
  182.  
  183. void
  184. draw_slider(int sid)
  185. {
  186.     struct slider_state *sp = &sliders[sid];
  187.     long wid = winget();
  188.     char buf[32];
  189.     float dx;
  190.  
  191.     if (sp->wid == -1)
  192.     return;
  193.  
  194.     winset(sp->wid);
  195.  
  196.     RGBcolor(200, 200, 200);
  197.     clear();
  198.  
  199.     RGBcolor(0, 0, 0);
  200.     cmov2(200., 5.);
  201.     sprintf(buf, "%5f", sp->val);
  202.     charstr(buf);
  203.     cmov2(5., 5.);
  204.     sprintf(buf, "%3f", sp->lo);
  205.     charstr(buf);
  206.     cmov2(420., 5.);
  207.     sprintf(buf, "%5f", sp->hi);
  208.     charstr(buf);
  209.  
  210.     dx = (sp->val - sp->lo) / sp->unit;
  211.     sp->ctl_points[1][X] =
  212.     sp->ctl_points[4][X] = dx + 10.;
  213.  
  214.     RGBcolor(0, 200, 0);
  215.     bgnpolygon();
  216.       v2f(sp->ctl_points[0]);
  217.       v2f(sp->ctl_points[1]);
  218.       v2f(sp->ctl_points[4]);
  219.       v2f(sp->ctl_points[5]);
  220.     endpolygon();
  221.  
  222.     RGBcolor(200, 200, 0);
  223.     bgnpolygon();
  224.       v2f(sp->ctl_points[1]);
  225.       v2f(sp->ctl_points[2]);
  226.       v2f(sp->ctl_points[3]);
  227.       v2f(sp->ctl_points[4]);
  228.     endpolygon();
  229.  
  230.     RGBcolor(0, 0, 0);
  231.     bgnclosedline();
  232.       v2f(sp->ctl_points[0]);
  233.       v2f(sp->ctl_points[2]);
  234.       v2f(sp->ctl_points[3]);
  235.       v2f(sp->ctl_points[5]);
  236.     endclosedline();
  237.     
  238.     swapbuffers();
  239.  
  240.     if (wid != -1)
  241.     winset(wid);
  242. }
  243.  
  244. int
  245. slider_event(int sid, short dev, short val)
  246. {
  247.     struct slider_state *sp = &sliders[sid];
  248.     void (*fun)(float);        /* compiler bug */
  249.     long wid;
  250.     
  251.     switch (dev) {
  252.  
  253.       case REDRAW:
  254.     if (val != sliders[sid].wid) {
  255.         fprintf(stderr, "slider: Unrecognized REDRAW (val = %d)\n", val);
  256.         break;
  257.     }
  258.     wid = winget();
  259.     winset(sp->wid);
  260.     reshapeviewport();
  261.     getorigin(&sp->orig[X], &sp->orig[Y]);
  262.     draw_slider(sid);
  263.     if (wid != -1)
  264.         winset(wid);
  265.     break;
  266.  
  267.       case WINQUIT:
  268.     if (val != sliders[sid].wid) {
  269.         fprintf(stderr, "slider: Unrecognized WINQUIT (val = %d)\n", val);
  270.         break;
  271.     }
  272.     close_slider(sid);
  273.     return(0);
  274.  
  275.       case ESCKEY:
  276.     if (val)
  277.         close_slider(sid);
  278.     return(0);
  279.  
  280.       case LEFTMOUSE:
  281.     sp->state = val? SLIDER_SLIDING: SLIDER_IDLE;
  282.     sp->omx = getvaluator(MOUSEX);
  283.     if (val) {
  284.         sp->val = sp->lo +
  285.               ((float)(sp->omx - sp->orig[X]) - sp->ctl_points[0][X])
  286.                   * sp->unit;
  287.         if (sp->val < sp->lo)
  288.         sp->val = sp->lo;
  289.         if (sp->val > sp->hi)
  290.         sp->val = sp->hi;
  291.         fun = sp->fun;
  292.         (*fun)(sp->val);
  293.     }
  294.     break;
  295.  
  296.       case MIDDLEMOUSE:
  297.     sp->state = val? SLIDER_SLIDING: SLIDER_IDLE;
  298.     sp->omx = getvaluator(MOUSEX);
  299.     break;
  300.  
  301.       case RIGHTMOUSE:
  302.     if (val) return(do_slider_menu(sid));
  303.     break;
  304.  
  305.       default:
  306.     fprintf(stderr, "slider: Unrecognized event (dev = %d, val = %d)\n",
  307.         dev, val);
  308.     break;
  309.     }
  310.  
  311.     return(1);
  312. }
  313.  
  314. void
  315. do_slider(int sid)
  316. {
  317.     struct slider_state *sp = &sliders[sid];
  318.     void (*fun)(float);        /* compiler bug */
  319.     short nmx;
  320.  
  321.     if (sp->state == SLIDER_IDLE)
  322.     return;
  323.     
  324.     nmx = getvaluator(MOUSEX);
  325.     sp->val += (float)(nmx - sp->omx) * sp->unit;
  326.     sp->omx = nmx;
  327.  
  328.     if (sp->val < sp->lo)
  329.     sp->val = sp->lo;
  330.     else
  331.     if (sp->val > sp->hi)
  332.     sp->val = sp->hi;
  333.     
  334.     fun = sp->fun;
  335.     (*fun)(sp->val);
  336.     draw_slider(sid);
  337. }
  338.  
  339. int
  340. do_slider_menu(int sid)
  341. {
  342.     struct slider_state *sp = &sliders[sid];
  343.     void (*fun)(float);        /* compiler bug */
  344.     char menu_buf[100];
  345.     int val;
  346.     
  347.     if (sp->menu == NULL) {
  348.     sprintf(menu_buf, "%s %%t|reset (to %g)|quit", sp->title, sp->dflt);
  349.     sp->menu = defpup(menu_buf);
  350.     }
  351.  
  352.     val = dopup(sp->menu);
  353.     switch (val) {
  354.       case -1:
  355.     break;
  356.  
  357.       case 1:
  358.     sp->val = sp->dflt;
  359.     fun = sp->fun;
  360.     (*fun)(sp->val);
  361.     draw_slider(sid);
  362.     break;
  363.     
  364.       case 2:
  365.     close_slider(sid);
  366.     return(0);
  367.  
  368.       default:
  369.     fprintf(stderr, "slider: Unrecognized menu selection (%d)\n", val);
  370.     break;
  371.     }
  372.  
  373.     return(1);
  374. }
  375.